package qc.module.ehs.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import qc.common.core.exception.QCPromptException;
import qc.common.core.unify.QCUnifyReturnValue;
import qc.common.core.utils.DateUtil;
import qc.common.core.utils.IdentifierUtil;
import qc.module.ehs.dto.checkrecord.CheckRecordDto;
import qc.module.ehs.dto.checkrecord.CheckRecordSaveResultDto;
import qc.module.ehs.entity.EhsCheckRecord;
import qc.module.ehs.mapper.EhsCheckRecordMapper;
import qc.module.ehs.repository.EhsCheckRecordRepository;
import qc.module.platform.dto.uac.UacUserInfoDto;

import java.util.Date;
import java.util.Objects;

/**
 * 检查记录接口Service
 *
 * @author QuCheng Tech
 * @create 2024/10/24
 */
@Service
public class EhsCheckRecordService {
    
    @Autowired
    private EhsCheckRecordRepository repository;

    @Autowired
    private EhsCheckTableService checkTableService;
    
    //@Autowired
    //private EhsTaskNodeRepository taskNodeRepository;

    /**
     * 新增检查记录
     *
     * @param dto 新增对象DTO
     * @return 返回检查记录ID，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/10/24
     */
    public String add(CheckRecordDto dto, UacUserInfoDto userInfo){
        //1.DTO有效性验证
        if (StringUtils.isBlank(dto.getTableid())) return QCUnifyReturnValue.Warn("检查表ID不能为空");
        if (StringUtils.isBlank(dto.getDataid())) return QCUnifyReturnValue.Warn("数据ID不能为空");
        if (!checkTableService.isExist(dto.getTableid())) return QCUnifyReturnValue.Warn("指定的检查表信息不存在");
        
        //2.DTO -> ENTITY
        EhsCheckRecord en = EhsCheckRecordMapper.MAPPER.toEntity(dto);
        en.setRecordid(IdentifierUtil.randomUUID());
        en.setUserid(userInfo.getId().toString());
        en.setIntm(DateUtil.getNowDate());
        en.setUpdatetm(DateUtil.getNowDate());
        
        //3.保存信息
        if (repository.insert(en) < 0x1){
            return QCUnifyReturnValue.Warn("保存失败");
        }
        return en.getRecordid();
    }

    /**
     * 修改检查记录
     *
     * @param dto 修改对象DTO
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/10/24
     */
    public String update(CheckRecordDto dto, UacUserInfoDto userInfo){
        //1.DTO有效性验证
        if (StringUtils.isBlank(dto.getRecordid())) return QCUnifyReturnValue.Warn("检查记录ID不能为空");
        if (StringUtils.isBlank(dto.getTableid())) return QCUnifyReturnValue.Warn("检查表ID不能为空");
        if (StringUtils.isBlank(dto.getDataid())) return QCUnifyReturnValue.Warn("数据ID不能为空");
        if (!isExist(dto.getRecordid())) return QCUnifyReturnValue.Warn("指定的检查记录不存在");
        if (!checkTableService.isExist(dto.getTableid())) return QCUnifyReturnValue.Warn("指定的检查表信息不存在");

        //2.DTO -> ENTITY
        EhsCheckRecord en = EhsCheckRecordMapper.MAPPER.toEntity(dto);
        en.setUserid(userInfo.getId().toString());
        en.setUpdatetm(DateUtil.getNowDate());
        
        //3.更新数据
        repository.updateById(en);
        return QCUnifyReturnValue.Success();
    }

    /**
     * 保存检查记录，自动根据检查表记录ID判断是否存在进行新增或修改
     *
     * @param checkrecord 保存对象Entity
     * @return CheckRecordSaveResultDto
     * @author QuCheng Tech
     * @description 根据是否传入检查记录ID确定是新增还是修改；如果有传入检查记录ID并且记录ID信息存在时为修改已有检查记录，否则新增检查记录；
     * 保存检查记录后返回保存的检查记录ID，由前端存储和调用；
     * @since 2024/10/25
     */
    public CheckRecordSaveResultDto save(EhsCheckRecord checkrecord) throws QCPromptException {
        CheckRecordSaveResultDto result = new CheckRecordSaveResultDto();
        result.setSuccess(false);

        //1.有效性验证
        if (StringUtils.isBlank(checkrecord.getTableid()))
            throw new QCPromptException("检查表ID不能为空");
        if (StringUtils.isBlank(checkrecord.getDataid()))
            throw new QCPromptException("数据ID不能为空");
        if (!checkTableService.isExist(checkrecord.getTableid()))
            throw new QCPromptException("指定的检查表信息不存在");

        //判断本次操作是新增还是修改
        boolean isUpdate = false;
        //如果传入的检查表记录ID为空判断为是新增
        if (StringUtils.isBlank(checkrecord.getRecordid())) {
            //生成一个ID作为检查表记录ID
            String recordId = IdentifierUtil.randomUUID();
            checkrecord.setRecordid(recordId);
        } else {
            //判断指定记录ID是否存在
            if (isExist(checkrecord.getRecordid()) == true)
                isUpdate = true;
        }

        if (isUpdate == false) {
            //如果是新增时设置写入时间和修改时间为当前时间
            Date now = DateUtil.getNowDate();
            checkrecord.setIntm(now);
            checkrecord.setUpdatetm(now);

            if (repository.insert(checkrecord) < 0x1) {
                result.setMsg("新增检查表记录信息失败");
            } else {
                result.setSuccess(true);
                result.setRecordid(checkrecord.getRecordid());
            }
        } else {
            //修改时设置修改的时间为当前时间
            checkrecord.setUpdatetm(DateUtil.getNowDate());

            if (repository.updateById(checkrecord) < 0x1) {
                result.setMsg("新增检查表记录信息失败");
            } else {
                result.setSuccess(true);
                result.setRecordid(checkrecord.getRecordid());
            }
        }

        return result;
    }

    /**
     * 删除检查记录
     *
     * @param id 检查记录ID
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/10/24
     */
    public String delete(String id) {
        repository.deleteById(id);
        return QCUnifyReturnValue.Success();
    }

    /***
     * 根据数据ID删除检查表记录
     *
     * @param dataId 数据ID
     * @return void
     * @author QuCheng Tech
     * @since 2025/1/17
     */
    public void deleteByDataId(String dataId) {
        LambdaQueryWrapper<EhsCheckRecord> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EhsCheckRecord::getDataid, dataId);

        repository.delete(wrapper);
    }

    /**
     * 获取指定检查记录
     *
     * @param id 检查记录ID
     * @return CheckRecordDto
     * @author QuCheng Tech
     * @since 2024/10/24
     */
    public CheckRecordDto get(String id) {
        EhsCheckRecord en = repository.selectById(id);
        if (Objects.nonNull(en)) {
            return EhsCheckRecordMapper.MAPPER.toDto(en);
        }
        return null;
    }

    /**
     * 获取指定检查记录 -- 根据指定的数据ID获取；
     *
     * @param id 数据ID，可能为节点ID或其他记录数据ID
     * @return CheckRecordDto
     * @author QuCheng Tech
     * @since 2024/10/24
     */
    public CheckRecordDto getByDataId(String id){
        LambdaQueryWrapper<EhsCheckRecord> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EhsCheckRecord::getDataid,id)
                .orderByDesc(EhsCheckRecord::getIntm);
        EhsCheckRecord en = repository.selectOne(wrapper);
        if (Objects.nonNull(en)){
            return EhsCheckRecordMapper.MAPPER.toDto(en);
        }
        return null;
    }

    /**
     * 指定检查记录是否存在
     *
     * @param id 检查记录ID
     * @return true表示存在，false表示不存在
     */
    public boolean isExist(String id){
        EhsCheckRecord en = repository.selectById(id);

        if (Objects.nonNull(en)) return true;
        return false;
    }
}
